﻿//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person 
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person 
//{
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
//void Func(Person* p)
//{
//	p->BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(&ps);
//	Func(&st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
//void Func(Person p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}


//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket(int i) { cout << "买票-半价" << endl; }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual Person* BuyTicket() { cout << "买票-全价" << endl; return new Person; }
//};
//
//class Student : public Person
//{
//public:
//	virtual Student* BuyTicket() { cout << "买票-半价" << endl; return new Student; }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual Person BuyTicket() { cout << "买票-全价" << endl; return Person(); }
//};
//
//class Student : public Person
//{
//public:
//	virtual Student BuyTicket() { cout << "买票-半价" << endl; return Student(); }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////析构函数时虚函数，构成重写
////析构函数名被特殊处理了，处理成了destructor
//class Person {
//public:
//	 ~Person() { cout << "~Person()" << endl; }
//};
//
//class Student : public Person {
//public:
//	 ~Student() { cout << "~Student()" << endl; }
//};
//
//int main()
//{
//	//普通对象
//	Person p;
//	Student s;
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////析构函数时虚函数，构成重写
////析构函数名被特殊处理了，处理成了destructor
//class Person {
//public:
//	 ~Person() { cout << "~Person()" << endl; }
//};
//
//class Student : public Person {
//public:
//	 ~Student() { cout << "~Student()" << endl; }
//};
//
//int main()
//{
//
//	Person p;
//	Student s;
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class Base1
//{
//public:
//	int _b1;
//};
//
//class Base2
//{
//public:
//	int _b2;
//};
//
//class Derive : public Base1, public Base2
//{
//public:
//	int _d;
//};
//
//int main()
//{
//	Derive d;
//
//	Base1* p1 = &d;
//
//	Base2* p2 = &d;
//
//	Derive* p3 = &d;
//
//	printf("%p\n", p1);
//	printf("%p\n", p2);
//	printf("%p\n", p3);
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class Base1
//{
//	
//public:
//	virtual void Print();
//	
//	int _b1;
//};
//
//void Base1::Print()
//{
//	cout << "hello wrold" << endl;
//}
//
//int main()
//{
//	
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class Base1
//{
//public:
//	int _b1;
//};
//
//class Base2
//{
//public:
//	int _b2;
//};
//
//class Derive : public Base1, public Base2
//{
//public:
//	int _d;
//};
//
//int main()
//{
//	Derive d;
//
//	Base1* p1 = &d;
//
//	Base2* p2 = &d;
//
//	Derive* p3 = &d;
//
//	printf("%p\n", p1);
//	printf("%p\n", p2);
//	printf("%p\n", p3);
//
//	return 0;
//}



//#include <iostream>
//using namespace std;
//
////析构函数时虚函数，构成重写
////析构函数名被特殊处理了，处理成了destructor
//class Person {
//public:
//	 virtual ~Person() { cout << "~Person()" << endl; }
//};
//
//class Student : public Person {
//public:
//	 virtual ~Student() { cout << "~Student()" << endl; }
//};
//
//int main()
//{
//
//	Person* p1 = new Person;
//	Person* p2 = new Student;
//
//	delete p1;
//	delete p2;
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
////析构函数时虚函数，构成重写
////析构函数名被特殊处理了，处理成了destructor
//class Person {
//public:
//	virtual ~Person() { cout << "~Person()" << endl; }
//};
//
//class Student : public Person {
//public:
//	virtual ~Student() { cout << "~Student()" << endl; }
//};
//
//int main()
//{
//
//	Person* p1 = new Person;
//	Person* p2 = new Student;
//
//	delete p1;
//	delete p2;
//
//	return 0;
//}


//#include <iostream>
//using namespace std;
//
////虚函数的重写允许两个都是虚函数或者父类是虚函数，在满足三同构成重写
////其实这个是C++不是很规范的地方，建议两个地方都加上virtual
//class Person
//{
//public:
//	virtual void BuyTicket() { cout << "买票-全价" << endl; }
//};
//
//class Student : public Person
//{
//public:
//	void BuyTicket() { cout << "买票-半价" << endl; }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}


//#include <iostream>
//using namespace std;
//
////多态
////静态的多态：函数重载，调用一个函数有不同的行为，原理是编译时期实现的
////动态的多态：一个父类的引用或者指针取调用同一个函数，传递不同的对象，会调用不同的函数：时运行时实现的
//class Person
//{
//public:
//	virtual const Person& BuyTicket() { cout << "买票-全价" << endl; return Person(); }
//};
//
//class Student : public Person
//{
//public:
//	virtual const Student& BuyTicket() { cout << "买票-半价" << endl; return Student(); }
//};
//
////构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
////不构成多态，调用的就是p的类型，跟自身类型有关
//void Func(Person& p)
//{
//	p.BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//
//	Func(ps);
//	Func(st);
//
//	return 0;
//}


#include <iostream>
using namespace std;

//虚函数的重写允许两个都是虚函数或者父类是虚函数，在满足三同构成重写
//其实这个是C++不是很规范的地方，建议两个地方都加上virtual
class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person
{
	void BuyTicket() { cout << "买票-半价" << endl; }
};

//构成多态，传的哪个类型的参数，调用的就是哪个类型的虚函数--跟对象有关
//不构成多态，调用的就是p的类型，跟自身类型有关
void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	min(1, 2);
	return 0;
}